#ifndef __WIZ_BNF_ACTOR_OPERATORS_BINARY_HPP__SHANHAOBO_19800429__
#define __WIZ_BNF_ACTOR_OPERATORS_BINARY_HPP__SHANHAOBO_19800429__

#include "../../Base/WizBase.hpp"

#include "./WizBNFActorResult.hpp"
#include "./WizBNFActorOperatorsRank.hpp"

namespace Wiz
{
    namespace BNF
    {
        namespace Actor
        {
            namespace Operators
            {
                namespace Binary
                {
                    template <typename OperationT, typename T0, typename T1>
                    struct Type;
                } /// end of namespace Binary
                ///////////////////////////////////////////////////////////////////////////////////////

                namespace Binary
                {
                    struct Assign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Assign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Assign, T0, T1>::tResult
                        operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Assign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Index
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Index, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Index, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Index, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct PlusAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<PlusAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<PlusAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<PlusAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct MinusAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<MinusAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<MinusAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<MinusAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct TimesAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<TimesAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<TimesAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<TimesAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct DivideAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<DivideAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<DivideAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<DivideAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct ModAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<ModAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<ModAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<ModAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct AndAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<AndAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<AndAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<AndAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct OrAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<OrAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<OrAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<OrAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct XorAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<XorAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<XorAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<XorAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct ShiftLeftAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeftAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeftAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeftAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct ShiftRightAssign
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRightAssign, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRightAssign, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRightAssign, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Plus
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Plus, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Plus, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Plus, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Minus
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Minus, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Minus, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Minus, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Times
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Times, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Times, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Times, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Divide
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Divide, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Divide, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Divide, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Mod
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Mod, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Mod, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Mod, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct And
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<And, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<And, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<And, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Or
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Or, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Or, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Or, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Xor
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Xor, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Xor, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Xor, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct ShiftLeft
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeft, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeft, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftLeft, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct ShiftRight
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRight, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRight, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<ShiftRight, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Equal
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Equal, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Equal, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Equal, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct NotEqual
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<NotEqual, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<NotEqual, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<NotEqual, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Less
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Less, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Less, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Less, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct LessEqual
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<LessEqual, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<LessEqual, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<LessEqual, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct Greater
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<Greater, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<Greater, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<Greater, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    struct GreaterEqual
                    {
                        template <typename T0, typename T1>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<GreaterEqual, T0, T1>::tResult tType;
                        };

                        template <typename T0, typename T1>
                        typename ::Wiz::BNF::Actor::Operators::Binary::Type<GreaterEqual, T0, T1>::tResult
                            operator()(T0& Lhs, T1& Rhs) const
                        {
                            return ::Wiz::BNF::Actor::Operators::Binary::Type<GreaterEqual, T0, T1>::Evaluate(Lhs, Rhs);
                        }
                    };

                    template <typename A0, typename A1>
                    struct LogicalAnd
                    {
                        typedef LogicalAnd tThis;

                        template <typename TupleT>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<
                                LogicalAnd, 
                                ::Wiz::BNF::Actor::Result<A0, TupleT>,
                                ::Wiz::BNF::Actor::Result<A1, TupleT>
                            >::tResult tType;
                        };

                        LogicalAnd(A0 const& _A0, A1 const& _A1) : m_A0(_A0), m_A1(_A1)
                        {

                        }

                        template <typename TupleT>
                        typename ::Wiz::BNF::Actor::Result<tThis, TupleT>::tType
                        Evaluate(TupleT const& Args) const
                        {
                            return m_A0.Evaluate(Args) && m_A1.Evaluate(Args);
                        }

                        A0 m_A0;
                        A1 m_A1;
                    };

                    template <typename A0, typename A1>
                    struct LogicalOr
                    {
                        typedef LogicalOr tThis;

                        template <typename TupleT>
                        struct Result
                        {
                            typedef typename ::Wiz::BNF::Actor::Operators::Binary::Type<
                                LogicalOr, 
                                ::Wiz::BNF::Actor::Result<A0, TupleT>,
                                ::Wiz::BNF::Actor::Result<A1, TupleT>
                            >::tResult tType;
                        };

                        LogicalOr(A0 const& _A0, A1 const& _A1) : m_A0(_A0), m_A1(_A1)
                        {

                        }

                        template <typename TupleT>
                        typename ::Wiz::BNF::Actor::Result<tThis, TupleT>::tType
                        Evaluate(TupleT const& Args) const
                        {
                            return m_A0.Evaluate(Args) || m_A1.Evaluate(Args);
                        }

                        A0 m_A0;
                        A1 m_A1;
                    };
                } /// end of namespace Binary
                ///////////////////////////////////////////////////////////////////////////////////////

                namespace Binary
                {
                    //////////////////////////////////
                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Assign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs = Rhs;
                        }
                    };

                    //////////////////////////////////
                    template <typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Index, ::Wiz::Null::Type, T1>
                    {
                        typedef ::Wiz::Null::Type         tResult;
                    };
                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Index, T0*, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0* Lhs, T1 const& Rhs)
                        {
                            return Lhs[Rhs];
                        }
                    };
                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Index, T0* const, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0* const Lhs, T1 const& Rhs)
                        {
                            return Lhs[Rhs];
                        }
                    };

                    template <typename T0, ::Wiz::Int::Type N, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Index, T0[N], T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0* Lhs, T1 const& Rhs)
                        {
                            return Lhs[Rhs];
                        }
                    };

                    //////////////////////////////////
                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::PlusAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs += Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::MinusAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs -= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::TimesAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs *= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::DivideAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs /= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::ModAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs %= Rhs;
                        }
                    };

                    //////////////////////////////////

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::AndAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs &= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::OrAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs |= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::XorAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs ^= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::ShiftLeftAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs <<= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::ShiftRightAssign, T0, T1>
                    {
                        typedef T0&         tResult;

                        static tResult Evaluate(T0& Lhs, T1 const& Rhs)
                        {
                            return Lhs >>= Rhs;
                        }
                    };

                    //////////////////////////////////

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Plus, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs + Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Minus, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs - Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Times, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs * Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Divide, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs / Rhs;
                        }
                    };


                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Mod, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs % Rhs;
                        }
                    };

                    //////////////////////////////////

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::And, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs & Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Or, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs | Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Xor, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs ^ Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::ShiftLeft, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs << Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::ShiftRight, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs >> Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Equal, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs == Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::NotEqual, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs != Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Less, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs < Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::LessEqual, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs <= Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::Greater, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs > Rhs;
                        }
                    };

                    template <typename T0, typename T1>
                    struct Type<::Wiz::BNF::Actor::Operators::Binary::GreaterEqual, T0, T1>
                    {
                        typedef typename ::Wiz::BNF::Actor::Operators::Rank::Higher<T0, T1>::tType const tResult;

                        static tResult Evaluate(T0 const& Lhs, T1 const& Rhs)
                        {
                            return Lhs >= Rhs;
                        }
                    };
                    //////////////////////////////////
                } /// end of namespace Binary
            } /// end of namespace Operators
        } /// end of namespace Actor
    } /// end of namespace BNF
} /// end of namespace Wiz

#endif /*__WIZ_BNF_ACTOR_OPERATORS_BINARY_HPP__SHANHAOBO_19800429__*/
